package com.order.manager.controller.Sender;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.order.manager.Model.*;
import com.order.manager.Model.other.RestBean;
import com.order.manager.service.impl.*;
import com.order.manager.util.JwtUtil;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.UUID;

/**
 * 配送员管理控制器
 * 处理配送员信息查询、审核、接单及订单状态更新等业务逻辑
 */
@RestController
@RequestMapping("/api/sender")
public class SenderController {

    // 注入配送员信息服务，用于操作配送员基础信息
    @Resource
    SenderInfoServiceImpl senderInfoService;

    // 注入JWT工具类，用于解析用户身份令牌
    @Resource
    JwtUtil jwtUtil;

    // 注入用户信息服务，用于关联用户与配送员角色
    @Resource
    UserInfoServiceImpl userInfoService;

    // 注入订单信息服务，用于操作订单状态
    @Resource
    OrderInfoServiceImpl orderInfoService;

    // 注入菜单信息服务（当前未使用，可能用于后续功能扩展）
    @Resource
    MenuInfoServiceImpl menuInfoService;

    // 注入订单配送信息服务，用于管理订单与配送员的关联
    @Resource
    OrderSendInfoServiceImpl orderSendInfoService;

    // 注入配送员审核信息服务，用于处理审核流程
    @Resource
    SenderExamineInfoServiceImpl senderExamineInfoService;

    /**
     * 获取当前登录用户的配送员信息
     * @param request HTTP请求对象，用于获取JWT令牌
     * @return 配送员信息或错误响应
     */
    @RequestMapping("/senderInfo")
    public RestBean UserInfo(HttpServletRequest request) {
        // 从请求头JWT中解析用户ID
        String uuid = jwtUtil.getJwtUsername(request);
        // 根据用户ID查询配送员信息
        SenderInfo senderInfo = senderInfoService.getOne(new QueryWrapper<SenderInfo>().eq("user_id", uuid));
        // 存在则返回成功响应，否则返回错误
        return senderInfo != null ? RestBean.success(senderInfo) : RestBean.failure(403, "没有该信息");
    }

    /**
     * 审核配送员申请
     * @param senderInfo 包含审核结果的配送员信息实体
     * @return 审核结果响应
     */
    @RequestMapping("/audit")
    public RestBean AuditSender(@RequestBody SenderInfo senderInfo) {
        // 根据配送员ID查询数据库中的配送员信息
        SenderInfo sender = senderInfoService.getById(senderInfo.getSenderId());
        // 更新审核状态
        sender.setIsPass(senderInfo.getIsPass());
        // 更新审核时间
        sender.setUpdateTime(new Date());

        // 根据配送员ID查询关联的用户信息
        UserInfo userInfo = userInfoService.getById(sender.getUserId());
        // 根据审核结果更新用户角色
        if (sender.getIsPass() != 1) {
            userInfo.setRole("student"); // 审核不通过，设为普通用户
        } else {
            userInfo.setRole("student_sender"); // 审核通过，设为配送员角色
        }
        // 保存用户角色更新
        userInfoService.updateById(userInfo);

        // 保存配送员审核状态更新，返回操作结果
        return senderInfoService.updateById(sender) ? RestBean.success(sender) : RestBean.failure(500, "审核失败");
    }

    /**
     * 查询在线配送员数量（状态为在线且已通过审核）
     * @return 在线配送员数量
     */
    @RequestMapping("/online/count")
    public RestBean onlineCount() {
        // 查询状态为1（在线）且审核通过（is_pass=1）的配送员数量
        return RestBean.success(senderInfoService.list(new QueryWrapper<SenderInfo>()
                .eq("state", 1).eq("is_pass", 1)).size());
    }

    /**
     * 查询所有已通过审核的配送员数量
     * @return 已通过审核的配送员总数
     */
    @RequestMapping("/count")
    public RestBean count() {
        // 查询审核通过（is_pass=1）的配送员数量
        return RestBean.success(senderInfoService.list(new QueryWrapper<SenderInfo>()
                .eq("is_pass", 1)).size());
    }

    /**
     * 申请成为配送员
     * @param senderExamineInfo 配送员审核资料实体
     * @param request HTTP请求对象，用于获取用户ID
     * @return 申请结果响应
     */
    @RequestMapping("/apply")
    public RestBean applySender(@RequestBody SenderExamineInfo senderExamineInfo, HttpServletRequest request) {
        // 从JWT中解析用户ID
        String uuid = jwtUtil.getJwtUsername(request);
        // 检查用户是否已注册为配送员
        if (senderInfoService.count(new QueryWrapper<SenderInfo>().eq("user_id", uuid)) == 0) {
            // 生成新的配送员ID
            String senderId = UUID.randomUUID().toString();
            // 创建配送员基础信息实体
            SenderInfo sender = new SenderInfo();
            sender.setInputTime(new Date());            // 设置注册时间
            sender.setState(1);                        // 设置配送员状态（1表示可用）
            sender.setIsPass(0);                       // 设置审核状态为待审核（0）
            sender.setUserId(uuid);                    // 关联用户ID
            sender.setSenderId(senderId);              // 设置配送员ID

            // 保存配送员基础信息
            if (!senderInfoService.save(sender)) {
                return RestBean.failure(500, "配送员信息创建失败");
            }

            // 关联审核资料与配送员ID
            senderExamineInfo.setSenderId(senderId);
            // 保存审核资料，返回操作结果
            return senderExamineInfoService.save(senderExamineInfo)
                    ? RestBean.success(sender)
                    : RestBean.failure(500, "申请配送员资格保存失败");
        }

        // 用户已注册为配送员，更新审核资料
        SenderInfo senderInfo = senderInfoService.getOne(new QueryWrapper<SenderInfo>().eq("user_id", uuid));
        String senderId = senderInfo.getSenderId();
        senderExamineInfo.setSenderId(senderId);

        // 检查是否已存在审核记录
        if (senderExamineInfoService.count(new QueryWrapper<SenderExamineInfo>().eq("sender_id", senderId)) != 0) {
            // 更新审核资料
            return senderExamineInfoService.updateById(senderExamineInfo)
                    ? RestBean.success(senderExamineInfo)
                    : RestBean.failure(500, "审核提交失败");
        }

        // 保存新的审核资料
        return senderExamineInfoService.save(senderExamineInfo)
                ? RestBean.success(senderExamineInfo)
                : RestBean.failure(500, "申请配送员审核资料保存失败");
    }

    /**
     * 配送员接单
     * @param request HTTP请求对象，用于身份验证
     * @param id 订单ID
     * @return 接单结果响应
     */
    @RequestMapping("/get/order/{id}")
    public RestBean senderGetOrder(HttpServletRequest request, @PathVariable String id) {
        // 从JWT中解析用户ID
        String uuid = jwtUtil.getJwtUsername(request);
        // 查询用户是否为已通过审核的配送员
        SenderInfo senderInfo = senderInfoService.getOne(new QueryWrapper<SenderInfo>()
                .eq("user_id", uuid).eq("is_pass", 1));
        if (senderInfo == null) return RestBean.failure(403, "当前状态不能接单");

        // 获取配送员ID
        String senderId = senderInfo.getSenderId();
        // 根据订单ID查询订单信息
        OrderInfo orderInfo = orderInfoService.getById(id);

        // 检查订单是否可接单（已支付、外卖类型、未被接单或已退单）
        if (orderInfo.getApplyState() != 1 || orderInfo.getType() != 2 ||
                orderSendInfoService.count(new QueryWrapper<OrderSendInfo>().eq("order_id", id)) != 0) {
            if (orderSendInfoService.getOne(new QueryWrapper<OrderSendInfo>().eq("order_id", id)).getState() != -1)
                return RestBean.failure(400, "该订单状态不能接单");
        }

        // 创建订单配送关联记录
        OrderSendInfo orderSendInfo = new OrderSendInfo();
        orderSendInfo.setOrderId(orderInfo.getOrderId());     // 关联订单ID
        orderSendInfo.setSenderId(senderId);                  // 关联配送员ID
        orderSendInfo.setState(0);                            // 设置状态为配送中（0）

        // 保存配送记录，返回操作结果
        return orderSendInfoService.save(orderSendInfo)
                ? RestBean.success(orderSendInfo)
                : RestBean.failure(500, "接单失败");
    }

    /**
     * 配送员修改订单配送状态
     * @param id 订单ID
     * @param state 新状态（-1取消，0配送中，1已送达）
     * @return 状态修改结果响应
     */
    @RequestMapping("/sender/state/{id}/{state}")
    public RestBean orderChargeState(@PathVariable String id, @PathVariable int state) {
        // 根据订单ID查询订单信息
        OrderInfo orderInfo = orderInfoService.getById(id);
        if (orderInfo == null) return RestBean.failure(403, "该订单信息错误");

        // 查询订单对应的配送记录
        OrderSendInfo orderSendInfo = orderSendInfoService.getOne(new QueryWrapper<OrderSendInfo>()
                .eq("order_id", id));
        if (orderSendInfo == null) {
            return RestBean.failure(403, "该订单没有配送员信息");
        }

        // 更新配送状态
        orderSendInfo.setState(state);

        // 若状态为取消（-1），则删除配送记录
        if (state == -1)
            return orderSendInfoService.removeById(id)
                    ? RestBean.success()
                    : RestBean.failure(500, "订单取消失败");

        // 否则更新配送状态，返回操作结果
        return orderSendInfoService.updateById(orderSendInfo)
                ? RestBean.success(orderSendInfo)
                : RestBean.failure(500, "订单状态修改失败");
    }

    /**
     * 获取配送员个人配送的订单列表（分页）
     * @param request HTTP请求对象，用于身份验证
     * @param page 页码
     * @param item 每页数量
     * @return 订单列表响应
     */
    @RequestMapping("/order/mySelf/{page}/{item}")
    public RestBean getMySenderOrder(HttpServletRequest request, @PathVariable int page, @PathVariable int item) {
        // 从JWT中解析用户ID
        String uuid = jwtUtil.getJwtUsername(request);
        // 查询用户对应的配送员信息
        SenderInfo senderInfo = senderInfoService.getOne(new QueryWrapper<SenderInfo>().eq("user_id", uuid));
        if (senderInfo == null) return RestBean.failure(403, "当前状态不能获取订单信息");
        // 调用服务层方法查询配送员的订单列表（分页）
        return RestBean.success(orderInfoService.queryByMyself(page, item, senderInfo.getSenderId()));
    }

    /**
     * 分页查询学校内的配送员列表
     * @param page 页码
     * @param item 每页数量
     * @return 配送员列表响应
     */
    @RequestMapping("/query/school/{page}/{item}")
    public RestBean queryBySchool(@PathVariable int page, @PathVariable int item) {
        // 调用服务层方法查询学校内的配送员列表（分页）
        return RestBean.success(senderInfoService.queryBySchool(page, item));
    }
}